pub fn test() {
    loop_test();
    match_test();
    ref_test();
    destructure_test();
}

fn loop_test() {
    'outer: loop {
        println!("进入外层循环");

        'inner: loop {
            print!("进入内层循环");
            break 'outer;
        }
        print!("永远都不会执行到这里");
    }
    print!("退出外层循环");
}
//其中|用于匹配多个值，...匹配一个范围 (包含最后一个值)，并且_在这里是必须的，
// 因为match强制进行穷尽性检查 (exhaustiveness checking)，必须覆盖所有的可能值。
// 如果需要得到...匹配到的值，可以使用@绑定变量：
fn match_test() {
    let day = 4;
    match day {
        0 | 6 => {
            println!("周末")
        },
        b @ 1...5 => {
            assert_eq!(b, 4);
            println!("工作日")
        },
        _ => println!("invalid"),
    }
}

//使用 ref 和 ref mut 在模式中创建引用
//这里我们将看到使用 ref 来创建引用，这样值的所有权就不会移动到模式的变量中。通常当匹配模式时，
//模式所引入的变量将绑定一个值。Rust 的所有权规则意味着这个值将被移动到 match 中，或者任何使用此模式的位置。
fn ref_test() {
    let x = 5;
    let mut y = 5;
    match x {
        // the `r` inside the match has the type `&i32`
        ref r => println!("Got a reference to {}", r),
    }
    match y {
        // the `mr` inside the match has the type `&i32` and is mutable
        ref mut mr => println!("Got a mutable reference to {}", mr),
    }
}

//解构元组、结构体、枚举
fn destructure_test() {
//    let pair = (0, -2);
    let pair = (1, -2);
    match pair {
        (0, y) => println!("x is 0 and y is {}", y),
        (x, 0) => println!("x is {} and y is 0", x),
        (x, y) => println!("x is {} and y is {}", x, y),
//        _ => println!("It doesn't matter what they are"),
    }
    //解构结构体
    struct Point {
        x: i32,
        y: i32,
    }

    let origin = Point{x: 0, y: 0};
    match origin {
        Point{x, ..} => println!("x is {}", x),
    }
    //解构枚举
    enum OptionalInt {
        Value(i32),
        Missing,
    }

    let x = OptionalInt::Value(5);
    match x {
        // 这里是 match 的 if guard 表达式，我们将在以后的章节进行详细介绍
        OptionalInt::Value(i) if i > 5 => println!("got an int bigger than five !"),
        OptionalInt::Value(..) => println!("got an int"),
        OptionalInt::Missing => println!("no such luck"),
    }

//    此外，Rust还引入了if let和while let进行模式匹配：
    let number = Some(7);
    let mut optional = Some(0);
    // If `let` destructures `number` into `Some(i)`, evaluate the block.
    if let Some(i) = number {
        println!("Matched {:?} !", i);
    }else {
        println!("didn't match a number !");
    }

    while let Some(i) = optional {
        if i > 9 {
            println!("greater than 9 , quit !");
            optional = None;
        }else {
            println!("i is {} , try again", i);
            optional = Some(i + 1);
        }
    }
}